#pragma once
#include "tfbondlib.h"
//#include "../../include/ssfilters.h"
#include <map>
#include <list>
#include "../core/Utility.h"
#include "../bondlib/BondInfo.h"
//#include "./BondField/QBond.h"


typedef unsigned long	DWORD;
typedef	unsigned int	UINT;
typedef unsigned char	BYTE;

// #define	SSBONDLIB_DATA_INVALID	0x7FFFFFFF
// 
// #define	SSBONDLIB_DAYS_INONEYEAR	240
// #define	SSBONDLIB_DAYS_CACHE		60
// #define	SSBONDLIB_DAYS_CALCULATE	30
// #define	SSBONDLIB_AUTORESUMEDR_DATEBEGIN	20040519
// #define	SSBONDLIB_AUTORESUMEDR_LIMIT		11
// 
// #define	SSBONDLIB_CODE_MAIN			"000001"
// #define	SSBONDLIB_CODE_MAINSZN		"399001"
// #define	SSBONDLIB_CODE_MAIN			"000001"
// #define	SSBONDLIB_CODE_MAINSZN		"399001"
// #define	SSBONDLIB_CODE_SZZS			"000001"	// 上证指数
// #define	SSBONDLIB_CODE_SZYBL		"000009"	// 上证180指数
// #define	SSBONDLIB_CODE_SZAG			"000002"	// 上证A股
// #define	SSBONDLIB_CODE_SZBG			"000003"	// 上证B股
// #define	SSBONDLIB_CODE_SZNCZ		"399001"	// 深证成指
// #define	SSBONDLIB_CODE_SZNZZ		"399106"	// 深证综指
// #define	SSBONDLIB_CODE_SZNCFAZ		"399002"	// 深证成份A指
// #define	SSBONDLIB_CODE_SZNCFBZ		"399003"	// 深证成份B指
// #define	SSBONDLIB_CODE_SZNFIRST		"000001"	// 深证第一支
// #define	SSBONDLIB_CODE_SHAFIRST		"600000"	// 上证第一支
// #define	SSBONDLIB_CODE_ZLDD			"000000"	// 主力大单
// 
// #define  SS_TWO_TF_FLAG "TS"//两年期
// 
// 
// // some fixed length
// #define	SSBONDLIB_MAX_CODE			12
// #define	SSBONDLIB_MAX_CODE2			16	// 兼容较长代码
// #define	SSBONDLIB_MAX_NAME			96
// #define	SSBONDLIB_MAX_NAMEENU		80
// #define	SSBONDLIB_MAX_SHORTNAME		32
// #define	SSBONDLIB_MAX_DOMAIN		32
// #define	SSBONDLIB_MAX_PROVINCE		32


// enum PriceTypes {
// 	Trade_Price		=	0x00,
// 	Indicative_Price =	0x01
// };
// 
// enum FreezeTypes {
// 	Normal_Price		=	0x00,
// 	Freeze_Price	=	0x01
// };
// some enum values
#pragma pack(push)
#pragma pack(1)

////////////////////////////////////////////////////////////////////////////////
// Summary:
//     common types for use,EAC
// Remarks:
//     EACH TYPEDEF MEANS A SPECIAL CODING
//     NO CODING COMMENTS MEANS ALL VISIBLE CHAR IS VALID INCLUDE Chinese character
//     Coding:a-z A-Z 0-9 ,;. 甲乙丙丁
//     tFieldName	: means typedefed fixed char array
//     tscFieldName	: means semicolon(;) splited char array
//           类型名称Name                    // 类型解释Comment			// 类型编码Coding
// typedef char tBondFullName[96];				// 债券全称,以'\0'结尾
// typedef char tBondShortName[32];			// 债券简称,以'\0'结尾
// typedef char tBondCode[SSBONDLIB_MAX_CODE];	// 证券代码,以'\0'结尾
// typedef char tMarketCode[4];				// 市场代码,以'\0'结尾
// typedef char tBondKey[33];					// 债券编码,
// typedef char tListedMarket[8];				// CIB/SSE/SZE 代表不同的市场 "CIB"
// typedef char tBondPublisher[8];				// 债券发行人
// typedef char tBrokerId[4];					// 经纪公司id
// typedef char tscListMarkets[128];			// 用';'隔开的流通市场
// typedef char tscWarranters[101];			// 用‘;’隔开的担保人
// typedef char tInterestRateType[3+1];		// 利率方式
// typedef char tBondRating[11];				// 债券评级
// typedef char tBondRateAgency[8];			// 债券评级机构
// typedef char tscUnderwriters[256];			// 主承销商
// typedef char tPriceStatus[4];				// 报价状态					// “0”：无报价，“1”：正常，“-”：1refer
// typedef char tDate8[12];					// 年月日日期					// 如："19860414"
// 通用类型
// typedef char tNullType[5];					//							// "NULL" 或者其他
// typedef char tNonType[4];					//							// "NON"  或者其他
// typedef char tFlagType;						// 1 或者 0

////////////////////////////////////////////////////////////////////////////////
// 债券静态数据结构

typedef struct KLine_t {
	float	m_fOpen;						// 开盘价
	float	m_fHigh;						// 最高价
	float	m_fLow;							// 最低价
	float	m_fClose;						// 收盘价
	float	m_PreClose;					// 昨收价
	float	m_AvgPrice;					// 平均价
} KLine, *PKLine;

// K线数据结构	CBondData::dataK
typedef struct kdata_t {
	DWORD				m_dwMarket;	
	tBondKey			m_sBondKey;				    // 债券编码
	tBondCode			m_szCode;						// 证券代码,以'\0'结尾
	DWORD				m_date;							// 日期 Format is YYMMDDHHMM for 5min, Format is YYYYMMDD for day-该注释是错误的！后台传过来的是time_t类型的！k线图是直接存储的！
	time_t				m_time;							// 时间　	与m_date一致．如果是是某日，则小时分秒均为0
	float				m_fOpen;						// 开盘价
	float				m_fHigh;						// 最高价
	float				m_fLow;							// 最低价
	float				m_fClose;						// 收盘价
	double				m_fAmount;						// 成交金额
	double				m_fVolume;						// 成交量
	double              m_fPosition;                    // 持仓量
	float				m_fSetPrc;						// 结算价
	DWORD				m_dwAdvance;					// 仅指数有效
	DWORD				m_dwDecline;					// 仅指数有效
	DWORD				m_dwReserved;

	bool operator< (const kdata_t &rhs) const
	{
		return m_time < rhs.m_time;
	}
	bool operator== (const kdata_t &rhs) const
	{
		return m_time == rhs.m_time;
	}
} KDATA, *PKDATA;



// 基本信息数据结构 CBondData::dataBasetbl
typedef struct basedata_t {
	tBondKey			m_sBondKey;					// 债券编码
	tBondCode			m_szCode;						// 证券代码,以'\0'结尾
	tBondFullName		m_szFull_Name;					// 债券全称
	tBondShortName		m_szShortName;					// 证券代码,以'\0'结尾
	time_t				m_time;							// 日期，time_t
	DWORD				m_date;				 			// 日期	Format is YYYYMMDD for base data
	tBondPublisher		m_Issuer_Code;					//发行人
	int					m_Maturity_Term;				// 偿还期限
	char				m_Term_Unit[3+1];				//单位，两字段合并显示
														//	*系统计算;//剩余期限(年)	 //客户端计算
														//	*系统计算;//距下一付息日天数 //not defined
														//	*系统计算;//当前付息周期天数 //not defined
	UINT				m_Listed_Date;					//上市日
	UINT				m_Delisted_Date;				//下市日
	UINT				m_Interest_Start_Date;		//起息日
	UINT				m_Maturity_Date;				//到期日
	tscListMarkets		m_Listed_Market;			    //流通市场
	double				m_Issue_Amount;				//发行总额(万元)
	                                                    //	*系统计算;//债券余额		 //not defined
	float				m_Issue_Price;					//发行价格
	char				m_Coupon_Type[3+1];			//利率方式
	float				m_Coupon_Rate_Current;		//最新票面利率(%)
	char				m_Coupon_Frequency[3+1];		//付息频率
	char				m_Compound_Frequency[3+1];	//计息频率
	tBondRating			m_Rating_Current;				//债项评级
	tBondRateAgency		m_Rating_Institution_Code;	//债项评级机构
	UINT				m_Rating_Date;					//债项评级日期
	tscUnderwriters 	m_Underwriter_Code;			//(同一债券若有多条记录,用';'隔开显示)主承销商
	tNonType			m_Option_Type;					//='NON'显示'否';否则显示'是'是否含权
	tNullType			m_Redemption_No;				//当Redemption_No=NULL显示'否';否则显示'是' 是否可提前偿还
	char 				m_Rating_Augment[3+1];		//信用增级方式
	tscWarranters		m_Warranter;					//(若有多条记录，用';'隔开显示)担保人
	char				m_Institution_rating[7+1];	//P_institution_rating	当Institution_Type=‘GRT’，取Rate担保人评级

}BASEDATA, *PBASEDATA;

/////////////////////////////////////////////////////////////////////////////////////////////
// 债券行情使用数据结构

// typedef struct bkquote_t {
// public:
// 	tBondKey		m_BondKey;						//bondkey
// 	tBondCode		m_BondCode;						//债券代码
// 	char		    m_ListedMarket[8];					//市场
// 
// 	char		    m_Bid[10];						//bid报价
// 	char		    m_BidYield[10];				//bid收益率，anson填
// 	char		    m_BidClean[10];				//bid净价，anson填
// 	char		    m_BidFull[10];					//bid全价，anson填
// 	char		    m_BidVol[12];					//bid数量
// 	tPriceStatus	m_BidStatus;					//bid状态，0--无报价，1--正常，-1--refer
// 	tFlagType		m_BidDiff2CDCFlag;			//bid偏离估值价标志
// 
// 	char		    m_Ofr[10];					//ofr报价
// 	char		    m_OfrYield[10];				//ofr收益率，anson填
// 	char		    m_OfrClean[10];				//ofr净价，anson填
// 	char		    m_OfrFull[10];				//ofr全价，anson填
// 	char		    m_OfrVol[12];				//ofr数量
// 	tPriceStatus	m_OfrStatus;				//ofr状态，0--无报价，1--正常,-1--refer
// 	tFlagType		m_OfrDiff2CDCFlag;			//bid偏离估值价标志
// 	char		m_Operation[4];					//报价标志，0--new，1--refer，2--unrefer，3--update(refresh),4--add 1,5--reduce1,6-move1,7--move-1,8--modify
// 	char		m_BCUserID[32+1];				//报价用户ID
// 	char		m_BCCompanyID[32+1];			//报价机构ID
// 	char		m_Freeze;						//1--冻结
// 	time_t		m_Time;							//价格最新时间，服务端时间
// } BKQUOTE, *PBKQUOTE;

// 行情刷新数据结构 CBondData::dataReport
// typedef struct price_t {
// 	char			m_id[32 + 1];
// 	char			m_bp_status[4];				// 订单状态 \n-1：待审核 \n0：发布\n1：成交\n2：作废
// 	char			m_flag_bargain[8];				// 可议价*
// 	char			m_flag_relation[8];				// OCO
// 	char			m_flag_vip[8];					// vip标记
// 	tBrokerId		m_company_id;					// 经纪公司ID
// 	//char	m_company_name[64];						// 经纪公司名称
// 	char			m_flag_bad[8];					// 危险标记
// 	char			m_price_status[3];				// 价格状态，0:报价被refer或deal掉了 1:报价发布或者报价删除或者内部报价
// 	char			m_rebate[4];					// 是否返点(0-不返，1返点)
// 	char			m_return_point[12];				// 返点值(例: F0.10)
// 	char			m_clean_price[12];				// 净价
// 	char			m_full_price[12];				// 全价
// 	char			m_yield_price[8];				// 收益率
// 	char			m_sPrice[12];					// 价
// 	char			m_quotetype[4];					// 报价类型，0-有意向；1-净价；2-全价；3-收益率；4-利差
// 	char			m_sVolume[64];					// 量
// 	char			m_description[128];				// 价格备注
// 	char			m_interpret[128];				// 拆解后的报价，格式(T+0,2000;T+1,2000;远期,2000)，Add by Lance, 2021/09/10
// 	char			m_exercise[2];					// '0'-行权，'1'-到期
// 	time_t			m_create_time;					// 创建时间
// 	time_t			m_time;							// 更新时间
// 	price_t(){
// 		memset(this, 0, sizeof(price_t));
// 	};
// public:
// 	bool IsPriceStatusValid()const{
// 		//价格状态只要不是0或者空即算有效
// 		return (strcmp(m_price_status, "") == 0 || strcmp(m_price_status, "0") == 0) ? false : true;
// 	}
// } PRICE, *PPRICE;

// 行情刷新数据结构--参考价
// typedef struct indx_price_t {
// //	tBondKey		m_bondkey;					//产品ID== bondkey
// 	char		    m_symbol[4];				//bid/ask标识	1--bid,-1,ofr，0--表示确却双边报价或者净价，在客户端不显示bid/ofr图标
// 	char		    m_price[12];				//参考价
// 	char		    m_clean_price[12];			//参考价
// 	tBrokerId		m_company_id;				//经纪公司ID
// 	time_t		    m_modify_time;				//datetime 
// 	//int			m_version;					//版本索引，每个公司唯一自增，从0开始
// } INDX_PRICE, *PINDX_PRICE;

// struct price_settlement {
// 	char	m_vol[16];		//量
// 	char	m_desc[64];		//原始备注
// 	char	m_typeold;		//'0'=T+0,'1'=T+1,'2'=远期
// 	char	m_bargin;		//'1'=需请示，'2'=必须请示
// 	BYTE	m_type;			//清算速度，1=T+0，2=T+1，4=远期，3,5,6,7为多选
// 	price_settlement()
// 	{
// 		memset(this, 0, sizeof(price_settlement));
// 	}
// };
// typedef std::list<price_settlement> PRICE_SETTLEMENT_LIST;

// typedef struct report_t {
// 	DWORD	        m_dwVersion;				// 报价版本号
// 	DWORD	        m_dwMarket;					// 证券市场类型,see CBondData::StockMarket
// 	tBondKey		m_sBondKey;					// 债券编码
// 	char			m_sListedMarket[8];			// 市场代码
// 	//tBondCode		m_szCode;					// 证券代码,以'\0'结尾
// 	//tBondShortName	m_szShortName;				// 证券代码,以'\0'结尾
// 	time_t	        m_time;						// 更新时间
// 	time_t	        m_create_time;				// 创建时间
// 	char	        m_bp_status[4];				// m_deal_status, 与成交区分，故改为bp_status, 订单状态 \n-1：待审核 \n0：发布\n1：成交\n2：作废
// 	//char	        m_flag_bargain[8];			// 可议价*
// 	//char	        m_flag_relation[8];			// OCO
// 	//char	        m_flag_vip[8];				// vip标记
// 	char			m_company_id[33];			// 经纪公司ID
// 	//char	        m_company_name[64];			// 经纪公司名称
// 	//char	        m_flag_bad[8];				// 危险标记
// 	char	        m_price_status[3];			// 价格状态，0:报价被refer或deal掉了 1:报价发布或者报价删除或者内部报价(0表示无效报价，非0表示有效报价)
// 	//char	        m_rebate[4];				// 是否返点
// 	//char	        m_return_point[12];			// 返点值
// 	//char	        m_clean_price[12];			// 净价
// 	//char	        m_sBuyPrice[12];			// 申买价
// 	//char	        m_sBuyVolume[64];			// 申买量
// 	//char	        m_sSellPrice[12];			// 申卖价
// 	//char	        m_sSellVolume[64];			// 申卖量
// 	//char	        m_description[128];			// 价格备注
// 	PRICE	        m_bidinfo;					// bid信息
// 	PRICE	        m_askinfo;					// ask信息
// 	INDX_PRICE	    m_indx_info;				// 指示价、参考价Indicative Price
// 	char	        m_price_sel;				// 价格选项，'0':bid ofr 报价，'1':参考价
// 	char			m_tradePrice[12];			//成交价格 (交易所报价页面使用，王绍旭 2015/01/22)
// 	__int64			m_pkg_id;					//网络包号
// public:
// 	bool IsPriceStatusValid()const{
// 		// bid/ask两边报价状态只要一个有效就算有效
// 		return m_bidinfo.IsPriceStatusValid() || m_askinfo.IsPriceStatusValid();
// 	}
// } REPORT, *PREPORT;
// 
// class xQBReportList_c
// {
// public:
// 	std::list<report_t> m_List;
// };


typedef struct quote_t {
	DWORD	        m_dwMarket;				// 证券市场类型,see CBondData::StockMarket
	tBondCode		m_szCode;					// 证券代码,以'\0'结尾
	char	        m_sProperty[32];			// 性质,以'\0'结尾，如：空换，多换，多平，空平，双平，多开，空开，双开
	int		        m_nFlag;					// 现量增仓性质标志
	int		        m_nIndex;					// 报价信息ID
	int		        m_milsec;					// 最后修改毫秒
	time_t	        m_time;						// 更新时间
	float	        m_fPrice;					// 最新价
	float	        m_fVolume;					// 最新一笔的数量
	float	        m_fIncrement;				// 仓差
	float	        m_BidPrice1;				// 申买价一
	float	        m_AskPrice1;				// 申卖价一
	float		    m_AveragePrice;		      //	当日均价 add by givins.zhu 2016 11/17
} QUOTE, *PQUOTE;

typedef struct S_TFBONDLIB_EXPORT quote_t_BigSet : public quote_t{//add by givins.zhu 2016/11/17 大单设置
	quote_t_BigSet(){
	}
	quote_t_BigSet(QUOTE& qt){
		m_dwMarket = qt.m_dwMarket;
		m_nFlag = qt.m_nFlag;
		m_nIndex = qt.m_nIndex;
		m_milsec = qt.m_milsec;
		m_time = qt.m_time;
		m_fPrice = qt.m_fPrice;
		m_fVolume = qt.m_fVolume;
		m_fIncrement = qt.m_fIncrement;
		m_BidPrice1 = qt.m_BidPrice1;
		m_AskPrice1 = qt.m_AskPrice1;
		m_AveragePrice = qt.m_AveragePrice;
		FIELDCOPY(m_szCode, qt.m_szCode);
		FIELDCOPY(m_sProperty, qt.m_sProperty);
		m_nSpeedSel = 0;
		m_nSpeedNumb = 0;
		m_nImpact = 0;
	}
	enum emTrigger{
		trigVol = 0,
		trigImpact,
		trigSpeed
	};
	int m_nSpeedSel;//涨速选择
	int m_nSpeedNumb;//涨速
	int m_nImpact;//冲击成本
	std::vector<int> m_vctTrigger;//触发值
	//void operator = (const QUOTE& qt){

	//}
} QUOTEBigSet, *PQUOTEBigSet;

typedef struct reportf_t {
	DWORD	        m_dwMarket;						// 证券市场类型,see CStock::StockMarket
	tBondCode	    m_szCode;	// 证券代码,以'\0'结尾
	time_t	        m_time;						// 交易时间
	int				m_nUpdateMillisec;			// 最后修改毫秒
	DWORD	        m_dwFlag;					// 停牌标志
	float	        m_fLast;					// 昨收（元）
	float	        m_fOpen;					// 今开（元）
	float	        m_fHigh;					// 最高（元）
	float	        m_fLow;						// 最低（元）
	float	        m_fNew;						// 最新（元）
	double	        m_fVolume;					// 成交量（股）
	double	        m_fAmount;					// 成交额（元）
	float	        m_fLstVolume;				// 最新数量（股）
	float	        m_fLstTurnover;			// 最新成交额（元）
	int	        m_fIncrementVol;			// 量差 非现量
	float	        m_fIncreTurnover;			// 本次成交额
	float	        m_fIncreInterest;			// 本次持仓差
	float	        m_OpenInterest;				// 持仓量（股）
	float	        m_fBuyPrice[5];				// 申买价（元）
	float	        m_fBuyVolume[5];			// 申买量（股）
	float	        m_fSellPrice[5];			// 申卖价（元）
	float	        m_fSellVolume[5];			// 申卖量（股）
	float		    m_AveragePrice;		//	当日均价 add by givins.zhu 2016 11/17
} REPORTF, *PREPORTF;

// 行情分时数据结构 CBondData::dataMinute
typedef struct minute_t {
	tBondKey		m_sBondKey;				// 债券编码
	tBondCode		m_szCode;					// 证券代码,以'\0'结尾
	tBondShortName	m_szShortName;				// 证券简称,以'\0'结尾
	DWORD	        m_dwMarket;						// 证券市场类型
	DWORD	        m_dwType;
	time_t	        m_time;						// 交易时间
	int				m_nUpdateMillisec;			// 最后修改毫秒
	float			m_fOpen;					// 开盘价
	float	        m_fHigh;					// 最高价
	float	        m_fLow;						// 最低价
	float	        m_fNew;						// 最新价
	float			m_fPreClose;				// 昨收价
	float	        m_fPosit;					// 持仓量
	double	        m_fVolume;					// 成交量
	double	        m_fAmount;					// 成交额

	bool operator== (const minute_t &rhs) const
	{
		return m_time == rhs.m_time;
	}
} MINUTE, *PMINUTE;

// 债券现金数据结构 CBondData::dataCash
typedef struct cash_t {
	DWORD	        m_dwType;					// 
	DWORD	        m_dwMarket;				// 证券市场类型,see CBondData::StockMarket
	tBondCode		m_szCode;					// 证券代码,以'\0'结尾
	time_t	        m_time;						// 交易时间
	float	        m_fHigh;					// 最高价（元）
	float	        m_fLow;						// 最低价（元）
	float	        m_fNew;						// 最新价（元）
	float	        m_fVolume;					// 成交量（股）
	float	        m_fAmount;					// 成交额（元）
} CASH, *PCASH;

typedef struct commpacket_t {
	DWORD	m_dwTag;			// = STKLIB_COMMPACKET_TAG
	DWORD	m_dwDataType;		// see CStock::DataType
	DWORD	m_dwCount;

	union
	{
		REPORTF *	m_pReport;		// 行情刷新数据
		MINUTE *	m_pMinute;		// 分时成交数据
		KDATA *		m_pKdata;		// 补充历史日线数据
		void *		m_pData;
	};
} COMMPACKET, *PCOMMPACKET;

/////////////////////////////////////////////////////////////////////////////////////////////
//交易所报价 add by lancezhao 20140819
// typedef struct xcquote_t{
// 	tBondKey		m_sBondKey;					// 债券编码
// 	//tBondCode		m_sBondCode;				// 证券代码,以'\0'结尾
// 	char		    m_sListedMarket[8];			// 市场
// 
// 	char			m_BidPriceYield[12];		// bid收益率
// 	char			m_BidPriceClean[12];		// bid净价
// 	char			m_BidVol[10];				// bid量
// 	char			m_OfrPriceYield[12];		// ofr收益率
// 	char			m_OfrPriceClean[12];		// ofr净价
// 	char			m_OfrVol[10];				// ofr量
// 
// 	time_t	        m_time;						// 交易时间
// }XCQUOTE, *PXCQUOTE;


// 债券行情使用数据结构结束
/////////////////////////////////////////////////////////////////////////////////////////////
#pragma pack(pop)


//#ifndef	SSBONDLIB_API
//#define	SSBONDLIB_API	__declspec(dllimport)
//#endif


/***
	财务资料数组类，可以记录多年的基本资料
*/
class S_TFBONDLIB_EXPORT CBaseData
{
public:
// Construction
	CBaseData();
	CBaseData( const CBaseData &src );

// Attributes
	int		GetSize() const;
	int		GetUpperBound() const;
	void	SetSize(int nNewSize, int nGrowBy = -1);

// Operations
	// Clean up
	void	FreeExtra();
	void	RemoveAll();

	// Accessing elements
	BASEDATA	GetAt(int nIndex) const;
	void	SetAt(int nIndex, const BASEDATA &newElement);
	BASEDATA&	ElementAt(int nIndex);

	// Direct Access to the element data (may return NULL)
	const BASEDATA* GetData() const;
	BASEDATA* GetData();

	// Potentially growing the array
	void	SetAtGrow(int nIndex, const BASEDATA & newElement);
	int		Add(const BASEDATA & newElement);

	// overloaded operator helpers
	BASEDATA	operator[](int nIndex) const;
	BASEDATA&	operator[](int nIndex);

	// Operations that move elements around
	void	InsertAt(int nIndex, const BASEDATA & newElement, int nCount = 1);
	void	RemoveAt(int nIndex, int nCount = 1);
	void	InsertAt(int nStartIndex, CBaseData* pNewArray);
	int		InsertBaseDataSort( const BASEDATA & newElement );
	void	Sort( );
	CBaseData	& operator = ( const CBaseData &src );
	void	Copy( const CBaseData &src );

// Implementation
protected:
	BASEDATA* m_pData;   // the actual array of data
	int m_nSize;     // # of elements (upperBound - 1)
	int m_nMaxSize;  // max allocated
	int m_nGrowBy;   // grow amount

public:
	~CBaseData();
};

//复权信息
class S_TFBONDLIB_EXPORT CKTFRightUnit{
public:
	CKTFRightUnit(){
		//m_stCurID = m_stFrontID = _T("");
		//m_nDate = 0;
		m_fCurYesClose = m_fFrontYesClose = 0.0f;
	}

	CKTFRightUnit	& operator = (const CKTFRightUnit &src){
		m_stCurID = src.m_stCurID;
		m_stFrontID = src.m_stFrontID;
		m_fCurYesClose = src.m_fCurYesClose;
		m_fFrontYesClose = src.m_fFrontYesClose;
		return *this;
	}
	std::string m_stCurID, m_stFrontID;
	//int m_nDate;
	float m_fCurYesClose, m_fFrontYesClose;  //昨收
	float GetReduce() const{
		if (m_fFrontYesClose > 0.01f && m_fCurYesClose > 0.01f) return m_fFrontYesClose - m_fCurYesClose;
		return 0.0f;
	}

};

class S_TFBONDLIB_EXPORT CKTFRightInfo{
public:
	CKTFRightInfo(){ m_tLastDate = -1; }
	~CKTFRightInfo(){ ; }
	void clear(){
		m_mapRecuce.clear();
	}
	//float GetRightPrice(const time_t& tTime, const float& fPrice) const{
	//	float fTemp,fRight = fPrice;
	//	for (map<time_t, CKTFRightUnit>::const_iterator itr = m_mapRecuce.begin();
	//		itr != m_mapRecuce.end(); itr++){
	//		if (tTime < itr->first){
	//			fTemp = itr->second.GetReduce();
	//			if (fTemp > 0.0001f) fRight -= fTemp;
	//			else bTotal = false;
	//		}
	//	}
	//	return fRight;
	//}

	float GetReduce(const time_t& tTime){
		float fTemp = 0.0f;
		for (std::map<time_t, CKTFRightUnit>::const_iterator itr = m_mapRecuce.begin();
			itr != m_mapRecuce.end(); itr++){
			if (tTime < itr->first){
				fTemp += itr->second.GetReduce();
				if (fTemp < 0.0001f && fTemp > -0.0001f) return 0.0f;
			}
		}
		return fTemp;
	}
	time_t GetLastDate(){
		if (m_tLastDate <= 0){
			std::map<time_t, CKTFRightUnit>::const_reverse_iterator itr = m_mapRecuce.rbegin();
			if (itr != m_mapRecuce.rend()){
				m_tLastDate = itr->first;
			}
		}
		return m_tLastDate;
	}

	std::map<time_t, CKTFRightUnit> m_mapRecuce;

	time_t m_tLastDate;
};

/***
	K线数据数组类
*/
class S_TFBONDLIB_EXPORT CKData
{
public:
	// Constructors
	CKData();
	CKData( int ktype, int maindatatype = mdtypeClose );
	CKData( const CKData & src );

	CKData	& operator = ( const CKData &src );
	static	bool	IsDayOrMin( int nKType );
	static  bool    IsSameDate( int nKType, DWORD dOrgDate, DWORD dNewDate); 

	// Flag values
	enum KTypes {					// 按照时间周期类型
		ktypeNone		=	0x00,	// 
		ktypeMin		=	0x01,	// 
		ktypeMin5		=	0x01,	//
		ktypeMin15		=	0x02,	//
		ktypeMin30		=	0x03,	//
		ktypeMin60		=	0x04,	//
		ktypeDay		=	0x05,	//
		ktypeWeek		=	0x06,	//
		ktypeMonth		=	0x07,	//
		ktypeYear		=	0x08,	//
		ktypeMax		=	0x08,	//
	};

	enum Formats {
		formatNone		=	0x00,
		formatMin		=	0x01,
		formatOriginal	=	0x01,
		formatXDRup		=	0x02,
		formatXDRdown	=	0x03,
		formatMax		=	0x03,
	};

	enum MaindataTypes {
		mdtypeNone		=	0x00,
		mdtypeMin		=	0x01,
		mdtypeClose		=	0x01,
		mdtypeOpen		=	0x02,
		mdtypeAverage	=	0x03,
		mdtypeMax		=	0x03,
	};

	// Attributes
	int		GetSize() const;
	int		GetUpperBound() const;
	void	SetSize(int nNewSize, int nGrowBy = -1);

	// Operations
	// Clean up
	void	FreeExtra();
	void	RemoveAll();

	// Accessing elements
	KDATA	GetAt(int nIndex) const;
	void	SetAt(int nIndex, const KDATA &newElement);
	KDATA&	ElementAt(int nIndex);

	// Direct Access to the element data (may return NULL)
	const KDATA* GetData() const;
	KDATA* GetData();

	float	MaindataAt(int nIndex);	// 得到CKData的nIndex日的主数据，根据主数据类型不同，返回值可能是开盘价、收盘价或者平均价
	bool	DateAt(int nIndex,
		int &nYear, int &nMonth, int &nDay, int &nHour, int &nMinute ) const;
	bool	LatestDate(
		int &nYear, int &nMonth, int &nDay, int &nHour, int &nMinute ) const;
	DWORD	GetDate(int nIndex );
	DWORD	GetDateDay( int nIndex );
	int		GetIndexByDate( DWORD date );
	int		GetAboutIndexByDate( DWORD date );

	// Potentially growing the array
	void	SetAtGrow(int nIndex, const KDATA & newElement);
	int		Add(const KDATA & newElement);

	// overloaded operator helpers
	KDATA	operator[](int nIndex) const;
	KDATA&	operator[](int nIndex);

	// Operations that move elements around
	void	InsertAt(int nIndex, const KDATA & newElement, int nCount = 1);
	void	RemoveAt(int nIndex, int nCount = 1);
	void	InsertAt(int nStartIndex, CKData* pNewArray);
	int		InsertKDataSort( const KDATA & newElement );

	// Operation of Analysis
	bool	IsNewValue( int nIndex, bool bTopOrBottom, int nDays );
	bool	GetMinMaxInfo( int nStart, int nEnd, float * pfMin, float *pfMax );

	// Implementation

	/************************************************************************/
	/* add by givins.zhu 2017/11/23                                        */
	/* 由于新需求需要对K线进行前复权,不复权计算                                    */
	/************************************************************************/
	void   RemoveFRight();//撤销前复权
	void   SetFRightInfo(const CKTFRightInfo& rightInfo);
	float  GetFRightOpen(int nIndex);//开盘
	float  GetFRightHign(int nIndex);//最高
	float  GetFRightLow(int nIndex);//最低
	float  GetFRightClose(int nIndex);//收盘
	float  GetFRightSetPrc(int nIndex);//结算
	bool   CheckIsFRight(int nIndex) const;//是否复权以及是否需要转换,根据规则，前复权是当前合约切换日前的所有价格需要转换

	float  GetFormatPrice(int nIndex, float fPrice);
	void   ShowCurrentOpen(int nIndex);

public:
	virtual ~CKData();

// #ifdef _DEBUG
// 	void AssertValid() const;
// 	void Dump() const;
// #endif

public:
	// Extra operations
	void	SetKType( int ktype );
	void	AutoSetKType( );
	int		GetKType( );
	int		GetCurFormat( );
	void	ChangeCurFormat( int format, DWORD dateAutoDRBegin, double dAutoDRLimit );
	void	SetMaindataType( int type );
	int		GetMaindataType( );
	void	RemoveDirty( );
	void	Clear( );

	int		CompareLatestDate( CKData &kd );
	static	int Min5ToMin15( CKData &kdm5, CKData &kdm15 );
	static	int Min5ToMin30( CKData &kdm5, CKData &kdm30 );
	static	int Min5ToMin60( CKData &kdm5, CKData &kdm60 );
	static	int DayToMonth( CKData &kdday, CKData &kdmonth );
	static	int DayToWeek( CKData &kdday, CKData &kdweek );

	DWORD	ToDayDate( DWORD date );

	int		MergeKData( CKData * pother );
	int		FullFillKData( CKData & kdataMain, bool bFillToEnd );

	bool	IsAdjacentDays( int nIndex, int nDays );
	bool	GetDiff( double * pValue, DWORD dateCur, int nDays );
	bool	GetDiffPercent( double * pValue, DWORD dateCur, int nDays );
	bool	GetScope( double * pValue, DWORD dateCur, int nDays );
	bool	GetVolumeSum( double * pValue, DWORD dateCur, int nDays );
	bool	GetRatioVolume( double * pValue, DWORD dateCur, int nDays );
	bool	GetRS( double * pValue, DWORD dateCur, int nDays );
	bool	GetMA( double * pValue, int nIndex, int nDays );

protected:
	static int		ConvertKData( CKData &kdSrc, CKData &kdDest, int multiple );
	void	CopyData( const CKData &src );
	void	LoadDataOriginal( );
	void	StoreDataOriginal( );
//	void	ConvertXDR( bool bUP, DWORD dateAutoDRBegin, double dAutoDRLimit );

//	static	float	GetRatio( float fLastClose, DRDATA & dr );

protected:
	KTypes			m_nKType;
	Formats			m_nCurFormat;
	MaindataTypes	m_nCurMaindataType;

	KDATA *			m_pDataOriginal;		//
	int				m_nSizeOriginal;		// 
	int				m_nMaxSizeOriginal;  // 

	KDATA *			m_pData;				// KDATA array,m_nMaxSize length,m_nSize valid
	int				m_nSize;				// 
	int				m_nMaxSize;			// 

	int				m_nGrowBy;				// grow amount

	bool   m_bFRight;//是否前复权
	//time_t m_tFRightTime;//前复权日期,此日期之前的数据需要平移
	//float  m_fFRightReduce;//前复权平移数值
	CKTFRightInfo m_RightInfo;
	std::map<DWORD, float> m_mapRgtReduce;//前复权
};

/***
	行情信息数据数组类
*/
class S_TFBONDLIB_EXPORT CBondReport
{
public:
// Construction
	CBondReport();
	CBondReport( const CBondReport &src );

// Attributes
	int		GetSize() const;
	int		GetUpperBound() const;
	void	SetSize(int nNewSize, int nGrowBy = -1);

// Operations
	// Clean up
	void	FreeExtra();
	void	RemoveAll();

	// Accessing elements
	REPORTF	GetAt(int nIndex) const;
	void	SetAt(int nIndex, const REPORTF &newElement);
	REPORTF&	ElementAt(int nIndex);

	// Direct Access to the element data (may return NULL)
	const REPORTF* GetData() const;
	REPORTF* GetData();

	// Potentially growing the array
	void	SetAtGrow(int nIndex, const REPORTF & newElement);
	int		Add(const REPORTF & newElement);

	// overloaded operator helpers
	REPORTF	operator[](int nIndex) const;
	REPORTF&	operator[](int nIndex);

	// Operations that move elements around
	void	InsertAt(int nIndex, const REPORTF & newElement, int nCount = 1);
	void	RemoveAt(int nIndex, int nCount = 1);
	void	InsertAt(int nStartIndex, CBondReport* pNewArray);
	int		InsertReportSort( const REPORTF & newElement );
	void	Sort( );
	void	RemoveDirty( );
	CBondReport	& operator = ( const CBondReport &src );
	void	Copy( const CBondReport &src );

	bool	GetMMLD( int nIndex, double *pdVolBuy, double *pdVolSell, double * pdVolDiff );	// 取得买卖力道指标值
	bool	GetMMLDMinMaxInfo( double *pdMin, double *pdMax );			// 取得买卖力道指标最大值最小值
	bool	StatBuySellEx( float * fSellPrice, float * fSellVolume, float * fBuyPrice, float * fBuyVolume, int nSize );
	bool	StatVolumeInfo( double *pdVolNow, double *pdVolOuter, double *pdVolInner );

// Implementation
protected:
	REPORTF*	m_pData;			// REPORTF array,m_nMaxSize length,m_nSize valid
	int			m_nSize;			// # of elements (upperBound - 1)
	int			m_nMaxSize;		// max allocated
	int			m_nGrowBy;			// grow amount

public:
	~CBondReport();
};

/***
	现金数据数组类
*/
class S_TFBONDLIB_EXPORT CBondQuote
{
public:
// Construction
	CBondQuote();
	CBondQuote( const CBondQuote &src );

// Attributes
	int		GetSize() const;
	int		GetUpperBound() const;
	void	SetSize(int nNewSize, int nGrowBy = -1);

// Operations
	// Clean up
	void	FreeExtra();
	void	RemoveAll();

	// Accessing elements
	QUOTE	GetAt(int nIndex) const;
	void	SetAt(int nIndex, const QUOTE &newElement);
	QUOTE&	ElementAt(int nIndex);

	// Direct Access to the element data (may return NULL)
	const QUOTE* GetData() const;
	QUOTE* GetData();

	// Potentially growing the array
	void	SetAtGrow(int nIndex, const QUOTE & newElement);
	int		Add(const QUOTE & newElement);

	// overloaded operator helpers
	QUOTE	operator[](int nIndex) const;
	QUOTE&	operator[](int nIndex);

	// Operations that move elements around
	void	InsertAt(int nIndex, const QUOTE & newElement, int nCount = 1);
	void	RemoveAt(int nIndex, int nCount = 1);
	void	InsertAt(int nStartIndex, CBondQuote* pNewArray);
	int		InsertQuoteSort( const QUOTE & newElement);
	void	Sort( );
	void	RemoveDirty( );
	CBondQuote	& operator = ( const CBondQuote &src );
	void	Copy( const CBondQuote &src );
	
	bool	StatVolumeInfo( double *pdVolNow, double *pdVolOuter, double *pdVolInner );	// 统计内盘外盘
	//bool	StatDealInfo( CSPDWordArray & adwPrice, CSPDWordArray & adwVolume, double * pdMaxVolume ); // 统计价量关系，返回值中的价格需乘以0.001
	bool	GetDiffPercentMin5( double * pValue );

	bool	GetIndexWave( double *pdWave, int nIndex );

//	int		ToKData( CKData & kdata );

// Implementation
protected:
	QUOTE*		m_pData;			// QUOTE array,m_nMaxSize length,m_nSize valid
	int			m_nSize;			// # of elements (upperBound - 1)
	int			m_nMaxSize;		// max allocated
	int			m_nGrowBy;			// grow amount

public:
	~CBondQuote();
};

/***
	行情分时数据数组类
*/
class S_TFBONDLIB_EXPORT CBondMinute
{
public:
// Construction
	CBondMinute();
	CBondMinute( const CBondMinute &src );

// Attributes
	int		GetSize() const;
	int		GetUpperBound() const;
	void	SetSize(int nNewSize, int nGrowBy = -1);

// Operations
	// Clean up
	void	FreeExtra();
	void	RemoveAll();

	// Accessing elements
	MINUTE	GetAt(int nIndex) const;
	void	SetAt(int nIndex, const MINUTE &newElement);
	MINUTE&	ElementAt(int nIndex);

	// Direct Access to the element data (may return NULL)
	const MINUTE* GetData() const;
	MINUTE* GetData();

	// Potentially growing the array
	void	SetAtGrow(int nIndex, const MINUTE & newElement);
	int		Add(const MINUTE & newElement);

	// overloaded operator helpers
	MINUTE	operator[](int nIndex) const;
	MINUTE&	operator[](int nIndex);

	// Operations that move elements around
	void	InsertAt(int nIndex, const MINUTE & newElement, int nCount = 1);
	void	RemoveAt(int nIndex, int nCount = 1);
	void	InsertAt(int nStartIndex, CBondMinute* pNewArray);
	int		InsertMinuteSort( const MINUTE & newElement );
	void	Sort( );
	void	RemoveDirty( );
	CBondMinute	& operator = ( const CBondMinute &src );
	void	Copy( const CBondMinute &src );
	
	bool	StatVolumeInfo( double *pdVolNow, double *pdVolOuter, double *pdVolInner );	// 统计内盘外盘
	//bool	StatDealInfo( CSPDWordArray & adwPrice, CSPDWordArray & adwVolume, double * pdMaxVolume ); // 统计价量关系，返回值中的价格需乘以0.001
	bool	GetDiffPercentMin5( double * pValue );

	bool	GetIndexWave( double *pdWave, int nIndex );

//	int		ToKData( CKData & kdata );

// Implementation
protected:
	MINUTE*		m_pData;		// MINUTE array,m_nMaxSize length,m_nSize valid
	int			m_nSize;		// # of elements (upperBound - 1)
	int			m_nMaxSize;	// max allocated
	int			m_nGrowBy;		// grow amount

public:
	~CBondMinute();
};

/***
	现金数据数组类
*/
class S_TFBONDLIB_EXPORT CBondCash
{
public:
// Construction
	CBondCash();
	CBondCash( const CBondCash &src );

// Attributes
	int		GetSize() const;
	int		GetUpperBound() const;
	void	SetSize(int nNewSize, int nGrowBy = -1);

// Operations
	// Clean up
	void	FreeExtra();
	void	RemoveAll();

	// Accessing elements
	CASH	GetAt(int nIndex) const;
	void	SetAt(int nIndex, const CASH &newElement);
	CASH&	ElementAt(int nIndex);

	// Direct Access to the element data (may return NULL)
	const CASH* GetData() const;
	CASH* GetData();

	// Potentially growing the array
	void	SetAtGrow(int nIndex, const CASH & newElement);
	int		Add(const CASH & newElement);

	// overloaded operator helpers
	CASH	operator[](int nIndex) const;
	CASH&	operator[](int nIndex);

	// Operations that move elements around
	void	InsertAt(int nIndex, const CASH & newElement, int nCount = 1);
	void	RemoveAt(int nIndex, int nCount = 1);
	void	InsertAt(int nStartIndex, CBondCash* pNewArray);
	int		InsertCashSort( const CASH & newElement );
	void	Sort( );
	void	RemoveDirty( );
	CBondCash	& operator = ( const CBondCash &src );
	void	Copy( const CBondCash &src );
	
	bool	StatVolumeInfo( double *pdVolNow, double *pdVolOuter, double *pdVolInner );	// 统计内盘外盘
	//bool	StatDealInfo( CSPDWordArray & adwPrice, CSPDWordArray & adwVolume, double * pdMaxVolume ); // 统计价量关系，返回值中的价格需乘以0.001
	bool	GetDiffPercentMin5( double * pValue );

	bool	GetIndexWave( double *pdWave, int nIndex );

//	int		ToKData( CKData & kdata );

// Implementation
protected:
	CASH*		m_pData;     // CASH array,m_nMaxSize length,m_nSize valid
	int			m_nSize;     // # of elements (upperBound - 1)
	int			m_nMaxSize;  // max allocated
	int			m_nGrowBy;   // grow amount

public:
	~CBondCash();
};

class CStDatabase;

/***
	单个期货信息类
*/
#define SUMSCOPE_BONDFUTURE_REALTIME_DAYS 6		//国债期货分时图最多显示几天
class S_TFBONDLIB_EXPORT CFutureInfo
{
public:
	CFutureInfo();
	~CFutureInfo();

public:
	void Clear( );
	CFutureInfo & operator = ( const CFutureInfo & si );

	bool	IsEqualTo( const char * szFutureID );
	bool	IsKeyEqualTo( const char * szFutureKey );
	DWORD	GetMarket( );
	void	SetMarket( DWORD dwMarket );
	const char * GetFutureKey( );
	const char * GetFutureCode( );
	//const char * GetMarketString( );
	//const char * GetMarketCNName( );
	bool	SetFutureKey( const char * szKey );
	bool	SetFutureCode( const char * szCode, bool bClear=true );

	const char * GetFutureName( );
	void	SetFutureName( const char * szName );

	// Attributes
	bool	IsValidFuture( );		// 期货信息是否正确
	int	DigitBit( );			// 得到价格有几位小数位

public:
	DWORD		m_dwMarket;							// 市场类型
	char		m_TF_Key[32];						//合约的key
	char		m_TF_ID[8];							//合约代码
	char		m_TF_ShortName[32];					//合约简称 
	char		m_sPinyin[128+1];					//拼音
	int			m_Delivery_Month;
	UINT		m_Last_Trading_Day;
	UINT		m_Delivery_Date;
	UINT		m_BondTerm;
	UINT		m_Deliverable_maturity_Start;
	UINT		m_Deliverable_maturity_End;
	char		m_Quoted_Way[16];
	float		m_Min_Change;
	char		m_Trading_Time[32];
	char		m_Last_Day_Trading_Time[32];
	float		m_Price_Limit;
	float		m_Lowest_Margins;
	char		m_Delivery_Way[16];
	char		m_Listed_Market[8];
	char		m_Is_Tradable[2];				//'Y'--可交易，“N”--不可交易
	int			m_type;							
	CKData		m_kdata;

public:
	char		m_TradingDay[8+1];	//	交易日
	char		m_InstrumentID[8];	//	合约代码
	char		m_InstrumentName[8];//	合约名称
	char		m_ExchangeID[8];	//	交易所代码
	char		m_ExchangeInstID[8];//	合约在交易所的代码
	DWORD		m_datebegin;		//	起始日期
	float		m_LastPrice;		//	最新价
	float		m_PreSettlementPrice;	//	上次结算价
	float		m_PreClosePrice;	//	昨收盘
	double		m_PreOpenInterest;	//	昨持仓量
	float		m_OpenPrice;		//	今开盘
	float		m_HighestPrice;		//	最高价
	float		m_LowestPrice;		//	最低价
	int			m_Volume;			//	数量
	double		m_Turnover;			//	成交金额
	int			m_LastVolume;		//	最新数量
	double		m_LastTurnover;		//	最新成交金额
	double		m_OpenInterest;		//	持仓量
	float		m_ClosePrice;		//	今收盘
	float		m_SettlementPrice;	//	本次结算价
	float		m_UpperLimitPrice;	//	涨停板价
	float		m_LowerLimitPrice;	//	跌停板价
	float		m_CurrDelta;		//	今虚实度
	float		m_PreDelta;			//	昨虚实度
	char		m_UpdateTime[24];	//	最后修改时间(HH:MM:SS)
	int			m_UpdateMillisec;	//	最后修改毫秒
	float		m_AveragePrice;		//	当日均价
	float		m_BidPrice1;		//	申买价一
	int			m_BidVolume1;		//	申买量一
	float		m_AskPrice1;		//	申卖价一
	int			m_AskVolume1;		//	申卖量一
	float		m_BidPrice2;		//	申买价二
	int			m_BidVolume2;		//	申买量二
	float		m_AskPrice2;		//	申卖价二
	int			m_AskVolume2;		//	申卖量二
	float		m_BidPrice3;		//	申买价三
	int			m_BidVolume3;		//	申买量三
	float		m_AskPrice3;		//	申卖价三
	int			m_AskVolume3;		//	申卖量三
	float		m_BidPrice4;		//	申买价四
	int			m_BidVolume4;		//	申买量四
	float		m_AskPrice4;		//	申卖价四
	int			m_AskVolume4;		//	申卖量四
	float		m_BidPrice5;		//	申买价五
	int			m_BidVolume5;		//	申买量五
	float		m_AskPrice5;		//	申卖价五
	int			m_AskVolume5;		//	申卖量五

};
/***
	单个债券信息类，禁用memcpy和memset等c函数，其它c++类执行同样标准

	brief:20150803 访问函数修改成const,支持const CBondInfo&引用传值
	
*/
class CAdditionBondInfo;



/*
	CBondInfo的具体实现选择开关宏
	当USE_BOND_DEBUG定义后,CBondInfoDebug将被typedef成CBondInfo
	当USE_BOND_OLD定义后,CBondInfoOld将被typedef成CBondInfo,这是原始的CBondInfo
	当USE_BOND_IMPL定义后,CBondInfoImpl将被typedef成CBondInfo

	CBondInfoDebug的优势:
		内部使用CBondInfoImpl指针,因此更改CBondInfoImpl.h头文件,无需重编整个工程
		这也是最终的版本
*/
//#define USE_BOND_IMPL
//#define USE_BOND_DEBUG

//#include "BondField/BondFilterFunc.h"
// class SSBONDLIB_API CBondInfoOld
// {
// public:
// 	typedef QBond::FieldInfo FieldInfo;
// 	typedef BondFilterFunc::_BONDFILTER _BONDFILTER;
// 	typedef CBondInfoOld ThisType;
// 	CBondInfoOld();
// 	~CBondInfoOld();
// public:
// 
// public:
// 	virtual void	Clear();//初始化数据	
// 	bool	IsCodeEqualTo(const char * szBondID, const char * szListedMarket)const;
// 	bool	IsKeyEqualTo(const char * szBondKey, const char * szListedMarket)const;
// 
// 	bool	IsEqualTo(const char * szBondID, const char * szListedMarket)const;//deprecated 
// 	//设置成员参数
// public:
// 	//2016/04/08 by devin.zhang:
// 	enum FilterCallbackType
// 	{
// 		FCT_NULL = 0,
// 		FCT_TYPE,	//产品类型
// 	};
// 
// 	//2016/12/08 by devin.zhang: 
// 	enum IssueTypes
// 	{
// 		IssueNONE = 0,	//未定义
// 		IssueRAT,		//利率
// 		IssuePRC,		//价格
// 		IssueSPD,		//利差
// 		IssueAMT,		//数量招标
// 	};
// 
// 	//typedef bool(__stdcall *_BONDFILTER)(UINT nBondType, const ThisType& bi);
// 
// 	class MAP_BONDFILTER
// 	{
// 	public:
// 		typedef std::map<UINT, ThisType::_BONDFILTER>::iterator ITR;
// 		std::map<UINT, ThisType::_BONDFILTER> mapFilter;
// 	};
// 
// public:
// 	void	SetBondKey( const char * szKey );							//m_sBondKey
// 	void	SetBondCode( const char * szCode );							//m_sBondID
// 	void	SetListedMarket( const char * szListedMarket );				//m_sListedMarket
// 	void	SetCombBondKey( const char * szKey );						//m_sCombBondKey
// 	void	SetCombBondCode( const char * szCode );						//m_sCombBondID
// 
// 																		//m_sJianpin
// 																		//m_sQuanpin 由SetBondShortName函数设置
// 
// 	void	SetMarketType( const char *szMarketType );					//m_sMarketType
// 	void	SetBondSubType(const char *szBondSubType);					//m_sBondSubType
// 	void	SetIssuerRating( const char *szIssuerRating );				//m_sIssuerRating
// 	void	SetIssuerRatingInstitutionCode( const char *sIssuerRatingInstitutionCode );//m_sIssuerRatingInstitutionCode
// 	void	SetBondRating( const char *szCurrent );						//m_sBondRating
// 	void	SetInstitutionRating( const char * sInstitutionRating);		//m_sInstitutionRating;
// 	void	SetListDate( const char *szListDate );						//m_sListDate
// 
// 	void	SetInterestStartDate( const char *szStartdate );			//m_sInterestStartDate
// 	void	SetMaturityDate( const char *szDate );						//m_sMaturityDate
// 	void	SetPaymentDate( const char * szPaymentDate );				//m_sPaymentDate
// 	void	SetOptionDate( const char *szOptionDate );					//m_sOptionDate
// 	void	SetRateType( const char *szRateType );						//m_sRateType
// 	void	SetCouponType( const char *szCouponType );					//m_sCouponType
// 	void	SetCouponFrequency( const char * szCouponFrequency );		//m_sCouponFrequency
// 	void	SetCompoundFrequency( const char * szCompoundFrequency );	//m_sCompoundFrequency
// 	void	SetInterestBasis( const char * szInterestBasis );			//m_sInterestBasis
// 
// 	void	SetOptionType( const char * szOptionType );					//m_sOptionType
// 	void	SetMaturityTerm( const char * szMaturityTerm );				//m_sMaturityTerm
// 	void	SetTermToMaturity( const char * szTermToMaturity );			//m_sTermToMaturity
// 	void	SetFRNIndexID( const char *szIndexID );						//m_sFRNIndexID
// 	void	SetFixingMADays( const char* szFixingMADays );				//m_sFixingMADays
// 	void	SetCouponRateCurrent( const char* szCouponRateCurrent );	//m_sCouponRateCurrent
// 
// 	void	SetPlannedIssueAmount( double fPlannedIssueAmount );		//m_fPlannedIssueAmount
// 	void	SetActualIssueAmount( double fActualIssueAmount );			//m_fActualIssueAmount
// 	void	SetOutstandingAmount( double fOutstandingAmount );			//m_fOutstandingAmount
// 	void	SetIssuerCode( const char * szIssuerCode );					//m_sIssuerCode
// 	void	SetInstitutionType( const char *szInsType );				//m_sInstitutionType
// 
// 	void	SetYieldCurveType( const char *szCurveType );				//m_sYieldCurveType
// 	
// 	//void	SetCSDate(UINT nCSDate);								//m_nCSDate
// 	//void	SetCSYield(const char *szYield);							//m_sCSYield	
// 	//void	SetCSCleanPrice( const char *szPrice );						//m_sCSCleanPrice
// 	//void	SetCSModifyDuration( const char *szDuration );				//m_sCSModifyDuration
// 
// 
// 	void	SetAutcionType(const char * szAutcionType);					//m_sAutcionType
// 	void	SetAuctionDateStart( const char * szAuctionDateStart );		//m_sAuctionDateStart
// 	void	SetAuctionDateEnd( const char * szAuctionDateEnd );			//m_sAuctionDateEnd
// 	void	SetAuctionDateTime( const char * szAuctionDateTime );		//m_sAuctionDateTime
// 	void	SetAnnounceDate( const char * szAnnounceDate );				//m_sAnnounceDate
// 	void	SetIssueType(const char * szIssueType);						//m_sIssueType
// 	void	SetIssueStartDate( const char * szIssueStartDate );			//m_sIssueStartDate
// 	void	SetIssueEndDate( const char * szIssueEndDate );				//m_sIssueEndDate
// 	void	SetIssueEndTime( const char * szIssueEndTime );				//m_sIssueEndTime
// 	void	SetIssuePeriod( const char * szIssuePeriod );				//m_sIssuePeriod
// 	void	SetAuctionTimeStart(int nAuctionTimeStart);					//m_nAuctionTimeStart
// 	void	SetAuctionTimeEnd(int nAuctionTimeEnd);						//m_nAuctionTimeEnd
// 
// 	void	SetQuotTopflag( int tp );									//m_nIsQuotTopflag
// 	void	SetWarrant( const char* szWarrant );						//m_sWarrant
// 	void	SetMortgage( char sMortgage );								//m_sMortgage
// 	void	SetCrossmarket( char sCrossmarket );						//m_sCrossmarket
// 	void	SetMunicipal( char sMunicipal );							//m_sIsMunicipal
// 	void	SetCBRRating(const char* szCBRRating);
// 	void	SetChinaDCState(const char* szChinaDCState);
// 	void	SetCDCRating(const char* szCDCRating);
// 	void	SetCSIRating(const char* szCSIRating);
// 	void	SetCurrency(const char* szCurrency);
// 	//m_bidinfo
// 	//m_askinfo
// //	bool	SetPriceInfo( REPORT * pReport, int bidask );				//m_bidinfo,m_askinfo
// 
// 	void	SetMainUnderwriters( const char * sUnderwriters);			//m_sMainUnderwriters
// 	void	SetJointUnderwriters( const char * sUnderwriters);			//m_sJointUnderwriters
// 	void	SetUnderwrites( const char * sUnderwrites);					//m_sUnderwrites
// 	void	SetBidLimitBottom( const char * sBid);						//m_sBidLimitBottom
// 	void	SetBidLimitTop( const char * sBid);							//m_sBidLimitTop
// 
// 	void	SetAuctionFlr( const char * sAuction);						//m_sAuction_Flr
// 	void	SetAuctionCap( const char * sAuction);						//m_sAuction_Cap
// 	void	SetAuctionStep( const char * sStep);						//m_sAuction_Step	
// 	void	SetAuctionUnit( const char * sUnit);						//m_sAuction_Unit
// 
// 	void	SetRemainDate(const char * sRemainDate);					//m_sRemainDate
// 	void	SetBondName( const char * szName );							//m_sFullName
// 	void	SetBondShortName( const char *szShortName );				//m_sShortName,m_sJianpin,m_sQuanpin
// 	void	SetBondNameEn( const char* szNameEn );						//m_sFullNameEn
// 	void	SetBondShortNameEn( const char* szShortNameEn );			//m_sShortNameEn
// 
// 	void    SetOutlook(const char * sOutlook);							//Outlook
// 	void    SetEntCor(const char *sEntCor);								//EntCor
// 
// 	void	SetBondFileNum(int nBondFileNum);							//m_nBondFileNum
// 	void	SetAdditionInfoIndex(int nIndex);							//m_nAdditionInfoIndex
// 	void	SetOptionInfoIndex(int nIndex);								//m_nOptionInfoIndex
// 
// 	void    SetIssueRate(const char * sIssueRate);						//m_IssueRate
// 	void	SetPlannedExerciseDate(const char * sDate);					//m_PlannedExerciseDate 
// 	void    SetNextCoupon_Date(const char *sDate);						//m_NextCoupon_Date
// 	void    SetConversionRate(const char* sRate);						//m_ConversionRate
// 	void    SetAssetStatus(const char* AssetStatus);					//m_sAssetStatus
// 
// 	void	SetCdcAuth(int nCdcAuth);									//m_nCdcAuth;
// 	void	SetExpireInHoliday(bool bHoliday);							//m_bExpireInHoliday
// 
// 	//得到成员函数,内联函数为了更好的效率
// public:
// 	const char * GetBondKey()		const;		//m_sBondKey
// 	const char * GetBondCode()		const;		//m_sBondID
// 	const char * GetListedMarket()	const;	//m_sListedMarket 获取市场代码
// 	const char * GetCombBondKey()	const;	//m_sCombBondKey 获取bondkey+market  eg: **********.CIB,  ****************.SSE,  **************.SZE
// 	const char * GetCombBondCode()	const;	//m_sCombBondID  获取bondcode+market  eg:  600000,   600000.SH,    600000.SZ
// 
// 	const char * GetBondJianpin( )	const;//m_sJianpin
// 	const char * GetBondQuanpin( )	const;//m_sQuanpin
// 	const char * GetMarketType()	const;	//m_sMarketType
// 	const char * GetBondSubType()	const;	//m_sBondSubType
// 	const char * GetIssuerRating()	const;	//m_sIssuerRating
// 	const char * GetIssuerRatingInstitutionCode() const; //m_sIssuerRatingInstitutionCode
// 	const char * GetInstitutionRating()const;//m_sInstitutionRating
// 
// 	const char * GetBondRating()	const;	//m_sBondRating
// 	const char * GetListDate( )		const;		//m_sListDate
// 	const char * GetInterestStartDate()const;//m_sInterestStartDate
// 	const char * GetMaturityDate()	const;	//m_sMaturityDate
// 	const char * GetPaymentDate()	const;	//m_sPaymentDate
// 
// 	const char * GetOptionDate( )	const;	//m_sOptionDate
// 	const char * GetRateType( )		const;		//m_sRateType
// 	const char * GetCouponType( )	const;	//m_sCouponType
// 	const char * GetCouponFrequency() const;	//m_sCouponFrequency
// 	const char * GetCompoundFrequency() const; //m_sCompoundFrequency
// 	const char * GetInterestBasis() const;//m_sInterestBasis
// 	const char * GetOptionType()	const;	//m_sOptionType
// 	const char * GetMaturityTerm()	const;	//m_sMaturityTerm
// 	const char*	 GetTermToMaturity()const;//根据相关条件特别处理了	 //修正的m_sTermToMaturity
// 	const char*	 GetTermToMaturity2D() const;//m_sTermToMaturity
// 	
// 	const char * GetFRNIndexID()	const;		//m_sFRNIndexID
// 	const char * GetFixingMADays()	const;	//m_sFixingMADays
// 	const char * GetCouponRateCurrent()	const;	//m_sCouponRateCurrent
// 
// 	double		 GetPlannedIssueAmount()	const;//m_fPlannedIssueAmount
// 	double		 GetActualIssueAmount()	const;	//m_fActualIssueAmount
// 	double		 GetOutstandingAmount() const;	//m_fOutstandingAmount
// 	const char * GetIssuerCode()	const;		//m_sIssuerCode
// 	const char * GetInstitutionType()const;	//m_sInstitutionType
// 
// 
// 	const char * GetYieldCurveType( )	const;	//m_sYieldCurveType
// 
// 	//UINT		 GetCSDate()			const;				//m_nCSDate
// 	//const char * GetCSYield()			const;				//m_sCSYield	
// 	//const char * GetCSCleanPrice( )		const;			//m_sCSCleanPrice
// 	//const char * GetCSModifyDuration( )	const;		//m_sCSModifyDuration
// 
// 	const char * GetAutcionType()		const;		//m_sAutcionType
// 	const char * GetAuctionDateStart()	const;
// 	const char * GetAuctionDateEnd()	const;
// 	const char * GetAuctionDateTime()	const;
// 	const char * GetAnnounceDate()		const;
// 	int			 GetIssueType();
// 	// PRIM - 3130  利差的判断条件：Auction表Auction_Type=SPD 或 bond表Coupon_Type=FRN  申购页面
// 	int			 GetIssueTypePurchase();
// 	const char * GetIssueStartDate()	const;
// 	const char * GetIssueEndDate()		const;
// 	const char * GetIssueEndTime()		const;
// 	const char * GetIssuePeriod()		const;
// 	int			 GetAuctionTimeStart()	const;
// 	int			 GetAuctionTimeEnd()	const;
// 
// 	int			 GetIsQuotTopflag()		const;
// 	char		 GetMortgage()			const;
// 	char		 GetCrossmarket()		const;
// 	char		 GetIsMunicipal()		const;
// 
// 	const char * GetWarrant()			const;
// 	const char * GetMainUnderwriters( )	const;	//m_sMainUnderwriters
// 	const char * GetJointUnderwriters( )const;	//m_sJointUnderwriters
// 	const char * GetUnderwrites( )		const;		//m_sUnderwrites
// 	const char * GetBidLimitBottom( )	const;	//m_sBidLimitBottom
// 	const char * GetBidLimitTop( )		const;		//m_sBidLimitTop
// 
// 	const char * GetAuctionFlr( )		const;		//m_sAuction_Flr
// 	const char * GetAuctionCap( )		const;		//m_sAuction_Cap
// 	const char * GetAuctionStep( )		const;		//m_sAuction_Step
// 	const char * GetAuctionUnit( )		const;		//m_sAuction_Unit
// 
// 	const char * GetRemainDate()		const;
// 	const char * GetBondName( )			const;		//m_sFullName
// 	const char * GetBondShortName( )	const;		//中文：m_sShortName;  英文:m_sFullNameEn
// 	const char * GetBondNameEn()		const;	//m_sFullNameEn
// 	const char * GetBondShortNameEn( )	const;	//m_sShortNameEn
// 
// 	const char * GetOutlook()			const;
// 	const char * GetEntCor()			const;
// 
// 	int			 GetBondFileNum()		const;		//m_nBondFileNum
// 	int			 GetOptionInfoIndex()	const;		//m_nOptionInfoIndex
// 
// 	const char *    GetIssueRate()				const;			
// 	const char *	GetPlannedExerciseDate()	const;
// 	const char *    GetNextCoupon_Date()		const;
// 	const char *    GetConversionRate()			const;
// 	const char *    GetAssetStatus()			const;
// 
// 	int			GetCdcAuth()		const;			//m_nCdcAuth
// 	int			GetOutlookLevel()	const;
// 	bool		IsExpireInHoliday() const;		//m_bExpireInHoliday
// 	const char *     GetCBRRating() const;
// 	const char *     GetChinaDCState() const;
// 	const char * GetCDCRating() const;
// 	const char * GetCSIRating() const;
// 	const char * GetCurrency() const;
// //////////////////////////////////////////////////////////////////////
// // 
// //其它函数
// public:
// 	const CAdditionBondInfo* GetAdditionInfo();					//m_nAdditionInfoIndex
// 	bool	IsAddIssueBond()const;									//判断是否增续发
// 	bool	IsFilterOutAddIssueBond()const;							//true表示需要过滤掉增续发券
// 
// //	const CBondOptionInfo* GetOptionInfo();					//m_nOptionInfoIndex
// 
// 	long	GetRemainedDays(time_t tNow) const;		//返回剩余期限加号前的时间
// 	const char * GetRemainPeriod(time_t tNow)const;	//获取剩余期限
// 	std::string GetHistoryRemainPeriod(time_t tday) const;	//获取任意时刻的剩余期限
// 	void	CalcRemainPeriod(time_t tNow);
// 	float	GetRemainYear(time_t tNow) const;			//获取剩余期限，返回浮点，单位年
// 	float	GetRemainYearToOption(time_t tNow) const;	//获取到行权日的剩余期限，返回浮点，单位年
// 
// 	int GetStorageBytes(int offset)const;
// 	int		GetMemoryBytes(int& validbytes)const;
// 	int		GetFieldByOffset(int offset, void* buf, int capcity, int& type, FieldAccessMode mode = FieldModeBytes)const;
// 	int		GetAllFields(std::vector<FieldInfo>& fields)const;
// 	static void RecordRepeatCheck();
// 	static void ChangeFieldMode(bool getName);
// public:
// 	void SetValidity(bool valid);
// 
// 	// Attributes
// 	bool	IsValidBond( )const;		// 债券信息是否正确
// 	bool	IsExpireBond()const;		// 已过期债券
// 	bool	IsRight( )const;			// 是否权证
// 	bool	IsNewBond( )const;			// 是否新发债
// 	bool	IsWarranted( )const;		// 债券是否担保
// 	bool	IsRebated( )const;			// 债券是否一级半，新发债
// 	bool	IsMortgage( )const;			// 债券是否可质押
// 	bool	IsCrossMarket( )const;		// 债券是否跨市场
// 	bool	IsSOEenterType( )const;		// 债券是否国企债
// 	bool	IsRatingDebt( )const;		// 是否利率债
// 	bool	IsMunicipal( )const;		// 是否城投债
// 	bool	IsInterbank()const;			// 是否银行间
// 	bool	IsExchange()const;			// 是否交易所
// 	bool    IsFinanceBond()const;		// 是否金融债
// 
// 	bool	GetQuotTopflag( )const;		// 取置顶报价
// 	int		DigitBit( )const;			// 得到价格有几位小数位
// 
// 	bool	MatchJianpin(const char* pstr)const;	//简拼匹配
// 	bool	MatchQuanpin(const char* pstr)const;	//全拼匹配
// 	
// 
// 	//@add by tony 20160218
// 	bool	CheckCommonUseType(const BLHCONDITION & Cond )const;	//判断常用：电力、钢铁等项
// 	bool	CheckCommonUseType( UINT nSubType )const;
// 	bool	IsCommonUseType(const string &sType)const; 
// 
// 
// 	bool	CheckBondType(const BLHCONDITION & Cond, _BONDFILTER bondtypefilter = NULL)const;		//判断产品类型：国债、央票等
// 	bool	CheckBondType( UINT nSubType )const;
// 
// 	bool	CheckCmbcBondType( BLHCONDITION & Cond )const;		//判断产品类型：金融债、短融、中票或私募 ABS
// 	bool	CheckCmbcBondType( UINT nSubType )const;
// 
// 	bool	CheckBjrcbBondType( BLHCONDITION & Cond )const;		//判断产品类型：国债、金融债、短融、中票、ABS、PPN
// 	bool	CheckBjrcbBondType( UINT nSubType )const;
// 
// 	bool	CheckNbcbCDBondType( BLHCONDITION & Cond )const;
// 	bool	CheckNbcbCDBondType( UINT nSubType )const;
// 
// 	bool	CheckNbcbIRDBondType( BLHCONDITION & Cond )const;
// 	bool	CheckNbcbIRDBondType( UINT nSubType )const;
// 
// 	bool	CheckNbcbIssueBondType( BLHCONDITION & Cond )const;
// 	bool	CheckNbcbIssueBondType( UINT nSubType )const;
// 
// 	bool	ShortCheckBondType(const BLHCONDITION & Cond )const;//短融、超短融类型判断,add bushion 20150810
// 	bool	ShortCheckBondType( UINT nSubType )const;//短融、超短融类型判断,add bushion 20150810
// 
// 	bool	CheckHYBondType(const BLHCONDITION & Cond)const;		//宏源旗舰店产品类型判断 add bushion 2016229
// 	bool    CheckHYBondType(UINT nSubType)const;
// 
// 	bool	CheckComplexBondType(const BLHCONDITION & Cond)const;
// 	bool    CheckComplexBondType(UINT nSubType)const;
// 
// 	bool	CheckBontSubType(const BLHCONDITION & Cond )const;	//判断产品类型细分：细分 例如国债：记账式国债、储蓄国债、凭证式国债
// 	bool	CheckBontSubType( const char* pSubType )const;
// 
// 	bool	CheckIssuer(const BLHCONDITION & Cond )const;		//判断发行人
// 	bool	CheckSector(const BLHCONDITION & Cond )const;		//判断行业
// 	bool	CheckArea(const  BLHCONDITION & Cond)const;			//判断地区
// 	bool	CheckMainUnderwriter(const BLHCONDITION& condStr) const;	//判断主承机构
// 
// 	bool	CheckDebtRating(const BLHCONDITION & Cond )const;	//判断债项  m_sBondRating
// 
// 	bool	CheckNCDRating(const BLHCONDITION& Cond)const;		//判断NCD 评级  add  by lbl
// 	
// 	bool	CheckFinDebt(const BLHCONDITION & Cond )const;		//判断金融债：国开，非国开
// 	bool	CheckIssueYear(const BLHCONDITION & Cond)const;		//判断发行年份
// 	bool	CheckIssueYear(int nBegin, int nEnd)const;
// 	bool	CheckUnderwriter(const BLHCONDITION & Cond )const;	//判断在团	
// 	bool	IsTransBond()const;								//CVB或者SCV
// 
// 	bool	IsCreditBond(const BLHCONDITION & Cond )const;		//信用债,利率债
// 	
// 	bool	is_interest_bond();
// 	bool	is_credit_bond();
// 	
// 	bool	IsSuperNewBond(const BLHCONDITION & Cond)const;		//超级新债通
// 	bool	IsInDays(const BLHCONDITION & Cond )const;			//年份：在发行、公告、缴款或者上市日期间 超级新债通过滤时间
// 	bool	CheckIssueState( BLHCONDITION & Cond ) const;	//发行状态判断:不限、发行中、已发行、预发行
// 
// 	bool	CheckAssetStatus(const BLHCONDITION & Cond) const;	//发行，公募，私募，小私募
// 	bool	CheckAssetStatus(UINT nStatus) const;
// 	bool	CheckABSCoupon(const BLHCONDITION & Cond) const;	//ABS票面
// 	bool	CheckABSCoupon(int nCouponType) const;
// 
// 	const char * GetArea(bool eng = false)const;			//地区名称
// 	const char * GetSwSector(bool eng = false)const;		//一级行业名称
// 	const char * GetSwSubSector(bool eng = false)const;		//二级行业名称
// 	const char * GetInstitutionShortName(bool eng = false)const;//机构简称
// 	const char * GetInstitutionFullName(bool eng = false) const;//发行人机构全称
// 	const char * GetRatingInstitutionShortName(bool eng = false)const;//评级机构简称
// 
// 	const char * GetCouponTypeName(bool eng = false)const;		//票面利率方式名称
// 	const char * GetOptionTypeName(bool eng = false)const;		//行权方式名称
// 	const char * GetOutlookName(bool eng = false)const;			//展望名称
// 	const char * GetIssuerBondRating() const;	//主体与债项评级组合字段
// 	const char * GetIssuerRatingEx() const ;	//m_sInstitutionRating为AAA+时，返回aaa+，否则返回m_sIssuerRating
// 	
// 	bool CheckBondSubType( const std::string& sType )const;//2016/08/29,bushion.xin:判断m_SubType
// 
// 	//产品债券类型判断函数，非通用的需要自己重写判断函数
// 	bool IsBondCountry() const;		//国债   1
// 	bool IsBondCenter() const;		//央票	 2
// 	bool IsBondFinance() const;		//金融债 3
// 	bool IsBondLocal() const;		//地方债 4
// 	bool IsBondShort() const;       //短融中包括超短融 5
// 	bool IsBondShort_S() const;     //短融中去掉超短融 5
// 	bool IsBondCShort() const;      //超短融 6
// 	bool IsBondChina() const;		//中票   7
// 
// 	bool IsBondEnterpr() const;		//企业债 8
// 	bool IsBondCorporate() const;	//公司债 9 （不含非公开公司债）
// 	bool IsBondNonPublicCor() const;//非公开公司债 10
// 	bool IsBondCOP() const;			//公司债（所有公司债，含9，10）
// 
// 	bool IsBondPPN() const;			//PPN  11
// 	bool IsBondNCD() const;			//NCD  12
// 	bool IsBondABS() const;			//ABS  13
// 	bool IsBondCRM() const;			//CRM  14
// 	bool IsBondPrivate() const;		//私募债 包括10和11
// 
// 
// 	bool IsBondSecondCapital() const;//二级资本债 15
// 	bool IsBondPDB() const;			 //熊猫债     16
// 	bool IsBondGKZ() const;			 //国开债     17
// 
// 	bool IsBondOther() const;		 //其它债     18  暂停使用，各页面自己负责其它债逻辑处理
// 
// 
// 	bool IsPrivateDebet() const;	//私募债，包括PPN和ABS 
// 
// 
// 	bool IsPrivateCorpBond() const ; //私募公司债
// 	bool IsPubliceCorpBond() const;  //公募公司债
// 	bool IsETSBond() const; //true表示永续债
// 	bool IsListedCompany()const;				//true表示上市公司债券
// 	bool IsCBRC_Financing_Platform()const;	//true表示平台债
// 
// 	bool IsCDCAuthValid() const; //是否有中债估值权限
// 
// private:
// 	tBondKey		m_sBondKey;							//债券编码  "A0000012012CORLEB01"
// 	tBondCode		m_sBondID;							//债券代码	"1280309"
// 	char			m_sListedMarket[8];					//CIB/SSE/SZE 代表不同的市场 "CIB"
// 	char			m_sCombBondKey[42];					//带有市场后缀的BondKey   "A0000012012CORLEB01.CIB"
// 	char			m_sCombBondID[20];					//带有市场后缀的BondCode  "1280309.IB"	
// 
// 	string			m_sJianpin;							//简拼					编码：------
// 	string			m_sQuanpin;							//全拼					编码：------
// 
// 	char			m_sMarketType[4];					//市场类型				1级，2级
// 	char			m_sBondSubType[4];					//债劵子类别:国债，央票等  参考BONDTYPE2LOG(UINT nType)函数 BGB,SGB等字符
// 	char			m_sIssuerRating[12];				//发行人最新评级,主体评级： AAA AA+等
// 	char			m_sIssuerRatingInstitutionCode[9];	//发行人评级机构代码
// 	char			m_sBondRating[12];					//最新债项评级： AAA AA+等
// 	char			m_sInstitutionRating[12];			//取institution_info表的institution_rating字段，主体评级，含AAA+
// 
// 	tDate8			m_sListDate;						//上市日期			    编码："20121019" YYYYMMDD(年月日)
// 	tDate8			m_sInterestStartDate;				//起息日				编码："20121010"
// 	tDate8			m_sMaturityDate;					//到期日				编码："20181010"
// 	tDate8			m_sPaymentDate;						//缴款日				编码："19860414"
// 	tDate8		    m_sOptionDate;						//行权日期				编码："19860414"
// 	char			m_sRateType[12];					//利率类型 票面			编码："Shibor","Depo","固息","FIXED" 
// 	char			m_sCouponType[12];					//利率方式				add by lance 2015.6.25
// 	char			m_sCouponFrequency[3+1];			//付息频率
// 	char			m_sCompoundFrequency[3+1];			//计息频率
// 	char			m_sInterestBasis[3+1];				//利息基础
// 
// 
// 	char			m_sOptionType[8];					//选择权类型			含权："NON" 显示'否';否则显示'是'是否含权
// 	char			m_sMaturityTerm[10];				//偿还期限	 "6Y"
// 	char			m_sTermToMaturity[16];				//偿还期限， "X+Y"
// 	char			m_sFRNIndexID[16];					//基础利率代码
// 	char			m_sFixingMADays[4];					//基准利率计算周期（平均）
// 	char			m_sCouponRateCurrent[12];			//中标价格,票面利率
// 	double			m_fPlannedIssueAmount;				//预期发行量		100000
// 	double			m_fActualIssueAmount;				//实际发行量		add by lance 2015.6.25
// 	double			m_fOutstandingAmount;				//债券余额（以万为单位）add by lance 2016.6.20
// 	char			m_sIssuerCode[8];					//发行人代码		"A000001" 判断金融债
// 	char			m_sInstitutionType[8];				//机构类型			"LGE"
// 
// 	string			m_sYieldCurveType;					//曲线类型			"CDC.CHI.MUB.AA-"
// 
// 	//UINT			m_nCSDate;							//中证估值日期
// 	//char			m_sCSYield[12];						//中证估值收益率
// 	//char			m_sCSCleanPrice[12];				//中证估值净价
// 	//char			m_sCSModifyDuration[8];				//中证估值久期
// 
// 	char			m_sAutcionType[8];					//发行方式
// 	tDate8			m_sAuctionDateStart;				//招标建档起始日
// 	tDate8			m_sAuctionDateEnd;					//招标建档截止日
// 	tDate8			m_sAuctionDateTime;					//招标建档时间
// 	tDate8			m_sAnnounceDate;					//公告日期
// 	tDate8			m_sIssueStartDate;					//发行起始日 "20121010"
// 	tDate8			m_sIssueEndDate;					//发行截止日
// 	tDate8			m_sIssueEndTime;					//发行截止时间	"1630"	add by lance 2015.6.25
// 	char			m_sIssuePeriod[16+1];				//募集时间 "9月上旬"等 add by lance 2015.9.9
// 	//char			m_sIsUnderwriter;					//是否在团 '0'
// 	int				m_nAuctionTimeStart;				//发行开始时间
// 	int				m_nAuctionTimeEnd;					//发行结束时间
// 	char			m_sIssueType[8 + 1];				//招标方式
// 
// 	int				m_nIsQuotTopflag;					//是否置顶,			编码: 1:置顶
// 	//int				m_nIsWarrant;						//担保
// 	char			m_sMortgage;						//可质押				编码："Y"
// 	char			m_sCrossmarket;						//跨市场				编码："Y","N"
// 	char			m_sIsMunicipal;						//城投					编码："Y"
// 
// 	char			m_sWarrant[32+1];			//担保
// 	char			m_sMainUnderwriters[32];	//主承销商 "X000068"
// 	string			m_sJointUnderwriters;		//联席承销商
// 	string			m_sUnderwrites;				//承销商列表，逗号分隔
// 	char			m_sBidLimitBottom[16];		//投标区间下限
// 	char			m_sBidLimitTop[16];			//投标区间上限
// 
// 	char			m_sAuction_Flr[16+1];		//标位下限
// 	char			m_sAuction_Cap[16+1];		//标位上限
// 	char			m_sAuction_Step[16+1];		//步长
// 	char			m_sAuction_Unit[8+1];		//标位单位
// 
// 	char			m_sRemainDate[32];			//剩余期限
// 	char			m_sRemainDateDisplay[32];	//界面显示的剩余期限
// 
// 	string			m_sFullName;				//债券全称
// 	string			m_sShortName;				//债券简称
// 	string			m_sFullNameEn;				//债券英文全称
// 	string			m_sShortNameEn;				//债券英文简称
// 
// 	char			m_sOutlook[8];				//展望
// 	char			m_sEntCor[8];				//公司标识字段
// 
// 	int				m_nBondFileNum;				//可下载文件数量
// 	int				m_nAdditionInfoIndex;		//增续发信息在vector中的index;
// 	int				m_nOptionInfoIndex;			//行权信息在vector中的index;
// 
// 	char			m_IssueRate[16];             //发行利率
// 	char			m_PlannedExerciseDate [9];   // 下一行权日
// 	char			m_NextCoupon_Date[9];        // 下一付息日
// 	char			m_ConversionRate[16];        // 质押比例
// 	char			m_sAssetStatus[8];			 // 资产类型 PRI-私募，PUB-小公募，NULL-公募
// 
// 	char			m_sCBRRating[12 + 1];	//中债资信评级
// 	char			m_sChinaDCState[12 + 1];	//中债资信状态
// 	char			m_sCDCRating[12 + 1];	//中债隐含评级
// 	char			m_sCSIRating[12 + 1];//中证隐含评级
// 	char			m_sCurrency[8];		//货币种类
// 
// 	int				m_nCdcAuth;							//中债估值对应权限
// 	bool			m_bExpireInHoliday;					//到期日是节假日
// 	int				m_nOutlookLevel;			//展望，用户排序
// 
// 	bool			m_bIsValid;					//true表示有效债券，否则为无效债券
// };

// #ifdef USE_BOND_OLD
// typedef CBondInfoOld CBondInfo;
// #elif defined USE_BOND_IMPL
// #include "BondField/CBondInfoImpl.h"
// typedef CBondInfoImpl CBondInfo;
// #elif defined USE_BOND_DEBUG
// #include "BondField/CBondInfoDebug.h"
// typedef CBondInfoDebug CBondInfo;
// #endif
// 
// typedef  CBondInfo  CQBBond;	//@add by Tony 2015.1.13


// class S_TFBONDLIB_EXPORT CBondData
// {
// public:
// 	CBondData();
// 	CBondData( CStDatabase * pDatabase );
// 	CBondData( CStDatabase * pDatabase, const char * code );
// 	~CBondData();
// 
// 	// Flag values
// 	enum StockMarket {
// 		marketUnknown	=	'UKNW',	// 未知
// 		marketSHSE		=	'ESHS',	// 上海证券交易所
// 		marketSZSE		=	'ESZS',	// 深圳证券交易所
// 	};
// 
// 	enum DataType {
// 		dataUnknown		=	0x00,		// 未知数据
// 		dataInfo		=	0x01,		// 债券信息
// 		dataReport		=	0x02,		// 债券刷新数据
// 		dataQuote		=	0x03,		// 债券报价数据
// 		dataOutline		=	0x04,		// 债券额外数据
// 		dataCash		=	0x05,		// 现金数据
// 		dataCredit		=	0x06,		// 信用数据
// 		dataDR			=	0x07,		// 债券权息数据
// 		dataK			=	0x08,		// 债券K线数据
// 		dataMinute		=	0x0A,		// 债券分时数据
// 		dataDetail		=	0x0B,		// 债券数据
// 		dataBase		=	0x0B,		// 债券数据
// 	};
// 
// 	enum ReportType	{
// 		reportUnknown	=	0x00,	//	未知
// 		reportQuarter	=	0x01,	//	第一季度季报
// 		reportMid		=	0x02,	//	中报
// 		reportQuarter3	=	0x03,	//	第三季度季报
// 		reportAnnals	=	0x04,	//	年报
// 	};
// 
// 	static	double GetReportFactor( int nReportType );
// 
// 	// Attributes
// 	void	SetDatabase( CStDatabase * pDatabase );
// 	CStDatabase * GetDatabase( );
// 	void	SetBondCode( const char * szCode , const char* szListedMarket);
// 	const char * GetBondCode( );
// 	bool	SetBondInfo( CBondInfo * pInfo );
// 	CBondInfo	&	GetBondInfo( );
// 	void	SetFutureCode( const char * szTFCode );
// 	const char * GetFutureCode( );
// 	bool	SetFutureInfo( CFutureInfo * pTFInfo );
// 	CFutureInfo	&	GetFutureInfo( );
// 	void	SetNetStatus( bool bStatus = true );
// 	CKData	&		GetKData( int ktype );
// 	CKData	&		GetKDataYear( );
// 	CKData	&		GetKDataMonth( );
// 	CKData	&		GetKDataWeek( );
// 	CKData	&		GetKDataDay( );
// 	CKData	&		GetKDataMin60( );
// 	CKData	&		GetKDataMin30( );
// 	CKData	&		GetKDataMin15( );
// 	CKData	&		GetKDataMin5( );
// 	CKData	&		GetDRData( );
// 	CBondQuote	&	GetQuote( );
// 	CBondReport &	GetReport( );
// 	CBondMinute &	GetMinute( );
// 	time_t			GetLastTime( );
// 
// 	// Operations
// 	void	Clear( );
// 	void	ClearTf( );
// 	bool	GetNetStatus( );
// 	void	SetLastTime( time_t lastdate = -1 );
// 	//int		PrepareData( int nDataType = dataInfo, bool bReload = false );
// 	int		PrepareData( int nDataType = dataInfo, int nKType = CKData::ktypeDay, bool bReload = false );
// 	int		ExtractKData( int nKType, bool bForced );
// 	int		MergeKData( CBondData &bond, int nKType );
// 	/************************************************************************/
// 	/* 设置复权                                                                     */
// 	/************************************************************************/
// 	void    SetFRightInfo(const CKTFRightInfo& rightInfo);
// 	void    RemoveFRight();//撤销前复权
// protected:
// 	void	SetKDataTypes( );
// 
// public:
// 	CStDatabase	* m_pDatabase;
// 	CFutureInfo	m_futureinfo;
// 	CBondInfo	m_bondinfo;
// 	CKData		m_kdYear;
// 	CKData		m_kdMonth;
// 	CKData		m_kdWeek;
// 	CKData		m_kdDay;
// 	CKData		m_kdMin60;
// 	CKData		m_kdMin30;
// 	CKData		m_kdMin15;
// 	CKData		m_kdMin5;
// 	CKData		m_drData;
// 	CBondQuote	m_bondquote;
// 	CBondReport m_bondreport;
// 	CBondMinute	m_bondminute;
// 	time_t		m_lastdate;
// 	bool		m_bStatus;
// };

#define _SP_ENABLE_INLINES
#ifdef	_SP_ENABLE_INLINES
#define	_BOND_INLINE	inline
#include "tfBondInfo.inl"
#undef	_BOND_INLINE
#endif
